/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

package entityprojet;

import entityprojet.exceptions.IllegalOrphanException;
import entityprojet.exceptions.NonexistentEntityException;
import entityprojet.exceptions.PreexistingEntityException;
import java.io.Serializable;
import javax.persistence.Query;
import javax.persistence.EntityNotFoundException;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

/**
 *
 * @author Ron
 */
public class FComptegJpaController implements Serializable {

    public FComptegJpaController(EntityManagerFactory emf) {
        this.emf = emf;
    }
    private EntityManagerFactory emf = null;

    public FComptegJpaController() {
        this.emf = Persistence.createEntityManagerFactory("projetT_RPU");
    }
    
    public EntityManager getEntityManager() {
        return emf.createEntityManager();
    }

    public void create(FCompteg FCompteg) throws PreexistingEntityException, Exception {
        if (FCompteg.getFComptetCollection() == null) {
            FCompteg.setFComptetCollection(new ArrayList<FComptet>());
        }
        if (FCompteg.getFTaxeCollection() == null) {
            FCompteg.setFTaxeCollection(new ArrayList<FTaxe>());
        }
        if (FCompteg.getFDocenteteCollection() == null) {
            FCompteg.setFDocenteteCollection(new ArrayList<FDocentete>());
        }
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            FCompter CRNum = FCompteg.getCRNum();
            if (CRNum != null) {
                CRNum = em.getReference(CRNum.getClass(), CRNum.getCbMarq());
                FCompteg.setCRNum(CRNum);
            }
            FTaxe TACode = FCompteg.getTACode();
            if (TACode != null) {
                TACode = em.getReference(TACode.getClass(), TACode.getCbMarq());
                FCompteg.setTACode(TACode);
            }
            Collection<FComptet> attachedFComptetCollection = new ArrayList<FComptet>();
            for (FComptet FComptetCollectionFComptetToAttach : FCompteg.getFComptetCollection()) {
                FComptetCollectionFComptetToAttach = em.getReference(FComptetCollectionFComptetToAttach.getClass(), FComptetCollectionFComptetToAttach.getCbMarq());
                attachedFComptetCollection.add(FComptetCollectionFComptetToAttach);
            }
            FCompteg.setFComptetCollection(attachedFComptetCollection);
            Collection<FTaxe> attachedFTaxeCollection = new ArrayList<FTaxe>();
            for (FTaxe FTaxeCollectionFTaxeToAttach : FCompteg.getFTaxeCollection()) {
                FTaxeCollectionFTaxeToAttach = em.getReference(FTaxeCollectionFTaxeToAttach.getClass(), FTaxeCollectionFTaxeToAttach.getCbMarq());
                attachedFTaxeCollection.add(FTaxeCollectionFTaxeToAttach);
            }
            FCompteg.setFTaxeCollection(attachedFTaxeCollection);
            Collection<FDocentete> attachedFDocenteteCollection = new ArrayList<FDocentete>();
            for (FDocentete FDocenteteCollectionFDocenteteToAttach : FCompteg.getFDocenteteCollection()) {
                FDocenteteCollectionFDocenteteToAttach = em.getReference(FDocenteteCollectionFDocenteteToAttach.getClass(), FDocenteteCollectionFDocenteteToAttach.getCbMarq());
                attachedFDocenteteCollection.add(FDocenteteCollectionFDocenteteToAttach);
            }
            FCompteg.setFDocenteteCollection(attachedFDocenteteCollection);
            em.persist(FCompteg);
            if (CRNum != null) {
                CRNum.getFComptegCollection().add(FCompteg);
                CRNum = em.merge(CRNum);
            }
            if (TACode != null) {
                FCompteg oldCGNumOfTACode = TACode.getCGNum();
                if (oldCGNumOfTACode != null) {
                    oldCGNumOfTACode.setTACode(null);
                    oldCGNumOfTACode = em.merge(oldCGNumOfTACode);
                }
                TACode.setCGNum(FCompteg);
                TACode = em.merge(TACode);
            }
            for (FComptet FComptetCollectionFComptet : FCompteg.getFComptetCollection()) {
                FCompteg oldCGNumPrincOfFComptetCollectionFComptet = FComptetCollectionFComptet.getCGNumPrinc();
                FComptetCollectionFComptet.setCGNumPrinc(FCompteg);
                FComptetCollectionFComptet = em.merge(FComptetCollectionFComptet);
                if (oldCGNumPrincOfFComptetCollectionFComptet != null) {
                    oldCGNumPrincOfFComptetCollectionFComptet.getFComptetCollection().remove(FComptetCollectionFComptet);
                    oldCGNumPrincOfFComptetCollectionFComptet = em.merge(oldCGNumPrincOfFComptetCollectionFComptet);
                }
            }
            for (FTaxe FTaxeCollectionFTaxe : FCompteg.getFTaxeCollection()) {
                FCompteg oldCGNumOfFTaxeCollectionFTaxe = FTaxeCollectionFTaxe.getCGNum();
                FTaxeCollectionFTaxe.setCGNum(FCompteg);
                FTaxeCollectionFTaxe = em.merge(FTaxeCollectionFTaxe);
                if (oldCGNumOfFTaxeCollectionFTaxe != null) {
                    oldCGNumOfFTaxeCollectionFTaxe.getFTaxeCollection().remove(FTaxeCollectionFTaxe);
                    oldCGNumOfFTaxeCollectionFTaxe = em.merge(oldCGNumOfFTaxeCollectionFTaxe);
                }
            }
            for (FDocentete FDocenteteCollectionFDocentete : FCompteg.getFDocenteteCollection()) {
                FCompteg oldCGNumOfFDocenteteCollectionFDocentete = FDocenteteCollectionFDocentete.getCGNum();
                FDocenteteCollectionFDocentete.setCGNum(FCompteg);
                FDocenteteCollectionFDocentete = em.merge(FDocenteteCollectionFDocentete);
                if (oldCGNumOfFDocenteteCollectionFDocentete != null) {
                    oldCGNumOfFDocenteteCollectionFDocentete.getFDocenteteCollection().remove(FDocenteteCollectionFDocentete);
                    oldCGNumOfFDocenteteCollectionFDocentete = em.merge(oldCGNumOfFDocenteteCollectionFDocentete);
                }
            }
            em.getTransaction().commit();
        } catch (Exception ex) {
            if (findFCompteg(FCompteg.getCbMarq()) != null) {
                throw new PreexistingEntityException("FCompteg " + FCompteg + " already exists.", ex);
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void edit(FCompteg FCompteg) throws IllegalOrphanException, NonexistentEntityException, Exception {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            FCompteg persistentFCompteg = em.find(FCompteg.class, FCompteg.getCbMarq());
            FCompter CRNumOld = persistentFCompteg.getCRNum();
            FCompter CRNumNew = FCompteg.getCRNum();
            FTaxe TACodeOld = persistentFCompteg.getTACode();
            FTaxe TACodeNew = FCompteg.getTACode();
            Collection<FComptet> FComptetCollectionOld = persistentFCompteg.getFComptetCollection();
            Collection<FComptet> FComptetCollectionNew = FCompteg.getFComptetCollection();
            Collection<FTaxe> FTaxeCollectionOld = persistentFCompteg.getFTaxeCollection();
            Collection<FTaxe> FTaxeCollectionNew = FCompteg.getFTaxeCollection();
            Collection<FDocentete> FDocenteteCollectionOld = persistentFCompteg.getFDocenteteCollection();
            Collection<FDocentete> FDocenteteCollectionNew = FCompteg.getFDocenteteCollection();
            List<String> illegalOrphanMessages = null;
            if (TACodeOld != null && !TACodeOld.equals(TACodeNew)) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("You must retain FTaxe " + TACodeOld + " since its CGNum field is not nullable.");
            }
            for (FComptet FComptetCollectionOldFComptet : FComptetCollectionOld) {
                if (!FComptetCollectionNew.contains(FComptetCollectionOldFComptet)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain FComptet " + FComptetCollectionOldFComptet + " since its CGNumPrinc field is not nullable.");
                }
            }
            for (FTaxe FTaxeCollectionOldFTaxe : FTaxeCollectionOld) {
                if (!FTaxeCollectionNew.contains(FTaxeCollectionOldFTaxe)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain FTaxe " + FTaxeCollectionOldFTaxe + " since its CGNum field is not nullable.");
                }
            }
            if (illegalOrphanMessages != null) {
                throw new IllegalOrphanException(illegalOrphanMessages);
            }
            if (CRNumNew != null) {
                CRNumNew = em.getReference(CRNumNew.getClass(), CRNumNew.getCbMarq());
                FCompteg.setCRNum(CRNumNew);
            }
            if (TACodeNew != null) {
                TACodeNew = em.getReference(TACodeNew.getClass(), TACodeNew.getCbMarq());
                FCompteg.setTACode(TACodeNew);
            }
            Collection<FComptet> attachedFComptetCollectionNew = new ArrayList<FComptet>();
            for (FComptet FComptetCollectionNewFComptetToAttach : FComptetCollectionNew) {
                FComptetCollectionNewFComptetToAttach = em.getReference(FComptetCollectionNewFComptetToAttach.getClass(), FComptetCollectionNewFComptetToAttach.getCbMarq());
                attachedFComptetCollectionNew.add(FComptetCollectionNewFComptetToAttach);
            }
            FComptetCollectionNew = attachedFComptetCollectionNew;
            FCompteg.setFComptetCollection(FComptetCollectionNew);
            Collection<FTaxe> attachedFTaxeCollectionNew = new ArrayList<FTaxe>();
            for (FTaxe FTaxeCollectionNewFTaxeToAttach : FTaxeCollectionNew) {
                FTaxeCollectionNewFTaxeToAttach = em.getReference(FTaxeCollectionNewFTaxeToAttach.getClass(), FTaxeCollectionNewFTaxeToAttach.getCbMarq());
                attachedFTaxeCollectionNew.add(FTaxeCollectionNewFTaxeToAttach);
            }
            FTaxeCollectionNew = attachedFTaxeCollectionNew;
            FCompteg.setFTaxeCollection(FTaxeCollectionNew);
            Collection<FDocentete> attachedFDocenteteCollectionNew = new ArrayList<FDocentete>();
            for (FDocentete FDocenteteCollectionNewFDocenteteToAttach : FDocenteteCollectionNew) {
                FDocenteteCollectionNewFDocenteteToAttach = em.getReference(FDocenteteCollectionNewFDocenteteToAttach.getClass(), FDocenteteCollectionNewFDocenteteToAttach.getCbMarq());
                attachedFDocenteteCollectionNew.add(FDocenteteCollectionNewFDocenteteToAttach);
            }
            FDocenteteCollectionNew = attachedFDocenteteCollectionNew;
            FCompteg.setFDocenteteCollection(FDocenteteCollectionNew);
            FCompteg = em.merge(FCompteg);
            if (CRNumOld != null && !CRNumOld.equals(CRNumNew)) {
                CRNumOld.getFComptegCollection().remove(FCompteg);
                CRNumOld = em.merge(CRNumOld);
            }
            if (CRNumNew != null && !CRNumNew.equals(CRNumOld)) {
                CRNumNew.getFComptegCollection().add(FCompteg);
                CRNumNew = em.merge(CRNumNew);
            }
            if (TACodeNew != null && !TACodeNew.equals(TACodeOld)) {
                FCompteg oldCGNumOfTACode = TACodeNew.getCGNum();
                if (oldCGNumOfTACode != null) {
                    oldCGNumOfTACode.setTACode(null);
                    oldCGNumOfTACode = em.merge(oldCGNumOfTACode);
                }
                TACodeNew.setCGNum(FCompteg);
                TACodeNew = em.merge(TACodeNew);
            }
            for (FComptet FComptetCollectionNewFComptet : FComptetCollectionNew) {
                if (!FComptetCollectionOld.contains(FComptetCollectionNewFComptet)) {
                    FCompteg oldCGNumPrincOfFComptetCollectionNewFComptet = FComptetCollectionNewFComptet.getCGNumPrinc();
                    FComptetCollectionNewFComptet.setCGNumPrinc(FCompteg);
                    FComptetCollectionNewFComptet = em.merge(FComptetCollectionNewFComptet);
                    if (oldCGNumPrincOfFComptetCollectionNewFComptet != null && !oldCGNumPrincOfFComptetCollectionNewFComptet.equals(FCompteg)) {
                        oldCGNumPrincOfFComptetCollectionNewFComptet.getFComptetCollection().remove(FComptetCollectionNewFComptet);
                        oldCGNumPrincOfFComptetCollectionNewFComptet = em.merge(oldCGNumPrincOfFComptetCollectionNewFComptet);
                    }
                }
            }
            for (FTaxe FTaxeCollectionNewFTaxe : FTaxeCollectionNew) {
                if (!FTaxeCollectionOld.contains(FTaxeCollectionNewFTaxe)) {
                    FCompteg oldCGNumOfFTaxeCollectionNewFTaxe = FTaxeCollectionNewFTaxe.getCGNum();
                    FTaxeCollectionNewFTaxe.setCGNum(FCompteg);
                    FTaxeCollectionNewFTaxe = em.merge(FTaxeCollectionNewFTaxe);
                    if (oldCGNumOfFTaxeCollectionNewFTaxe != null && !oldCGNumOfFTaxeCollectionNewFTaxe.equals(FCompteg)) {
                        oldCGNumOfFTaxeCollectionNewFTaxe.getFTaxeCollection().remove(FTaxeCollectionNewFTaxe);
                        oldCGNumOfFTaxeCollectionNewFTaxe = em.merge(oldCGNumOfFTaxeCollectionNewFTaxe);
                    }
                }
            }
            for (FDocentete FDocenteteCollectionOldFDocentete : FDocenteteCollectionOld) {
                if (!FDocenteteCollectionNew.contains(FDocenteteCollectionOldFDocentete)) {
                    FDocenteteCollectionOldFDocentete.setCGNum(null);
                    FDocenteteCollectionOldFDocentete = em.merge(FDocenteteCollectionOldFDocentete);
                }
            }
            for (FDocentete FDocenteteCollectionNewFDocentete : FDocenteteCollectionNew) {
                if (!FDocenteteCollectionOld.contains(FDocenteteCollectionNewFDocentete)) {
                    FCompteg oldCGNumOfFDocenteteCollectionNewFDocentete = FDocenteteCollectionNewFDocentete.getCGNum();
                    FDocenteteCollectionNewFDocentete.setCGNum(FCompteg);
                    FDocenteteCollectionNewFDocentete = em.merge(FDocenteteCollectionNewFDocentete);
                    if (oldCGNumOfFDocenteteCollectionNewFDocentete != null && !oldCGNumOfFDocenteteCollectionNewFDocentete.equals(FCompteg)) {
                        oldCGNumOfFDocenteteCollectionNewFDocentete.getFDocenteteCollection().remove(FDocenteteCollectionNewFDocentete);
                        oldCGNumOfFDocenteteCollectionNewFDocentete = em.merge(oldCGNumOfFDocenteteCollectionNewFDocentete);
                    }
                }
            }
            em.getTransaction().commit();
        } catch (Exception ex) {
            String msg = ex.getLocalizedMessage();
            if (msg == null || msg.length() == 0) {
                Integer id = FCompteg.getCbMarq();
                if (findFCompteg(id) == null) {
                    throw new NonexistentEntityException("The fCompteg with id " + id + " no longer exists.");
                }
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            FCompteg FCompteg;
            try {
                FCompteg = em.getReference(FCompteg.class, id);
                FCompteg.getCbMarq();
            } catch (EntityNotFoundException enfe) {
                throw new NonexistentEntityException("The FCompteg with id " + id + " no longer exists.", enfe);
            }
            List<String> illegalOrphanMessages = null;
            FTaxe TACodeOrphanCheck = FCompteg.getTACode();
            if (TACodeOrphanCheck != null) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This FCompteg (" + FCompteg + ") cannot be destroyed since the FTaxe " + TACodeOrphanCheck + " in its TACode field has a non-nullable CGNum field.");
            }
            Collection<FComptet> FComptetCollectionOrphanCheck = FCompteg.getFComptetCollection();
            for (FComptet FComptetCollectionOrphanCheckFComptet : FComptetCollectionOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This FCompteg (" + FCompteg + ") cannot be destroyed since the FComptet " + FComptetCollectionOrphanCheckFComptet + " in its FComptetCollection field has a non-nullable CGNumPrinc field.");
            }
            Collection<FTaxe> FTaxeCollectionOrphanCheck = FCompteg.getFTaxeCollection();
            for (FTaxe FTaxeCollectionOrphanCheckFTaxe : FTaxeCollectionOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This FCompteg (" + FCompteg + ") cannot be destroyed since the FTaxe " + FTaxeCollectionOrphanCheckFTaxe + " in its FTaxeCollection field has a non-nullable CGNum field.");
            }
            if (illegalOrphanMessages != null) {
                throw new IllegalOrphanException(illegalOrphanMessages);
            }
            FCompter CRNum = FCompteg.getCRNum();
            if (CRNum != null) {
                CRNum.getFComptegCollection().remove(FCompteg);
                CRNum = em.merge(CRNum);
            }
            Collection<FDocentete> FDocenteteCollection = FCompteg.getFDocenteteCollection();
            for (FDocentete FDocenteteCollectionFDocentete : FDocenteteCollection) {
                FDocenteteCollectionFDocentete.setCGNum(null);
                FDocenteteCollectionFDocentete = em.merge(FDocenteteCollectionFDocentete);
            }
            em.remove(FCompteg);
            em.getTransaction().commit();
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public List<FCompteg> findFComptegEntities() {
        return findFComptegEntities(true, -1, -1);
    }

    public List<FCompteg> findFComptegEntities(int maxResults, int firstResult) {
        return findFComptegEntities(false, maxResults, firstResult);
    }

    private List<FCompteg> findFComptegEntities(boolean all, int maxResults, int firstResult) {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            cq.select(cq.from(FCompteg.class));
            Query q = em.createQuery(cq);
            if (!all) {
                q.setMaxResults(maxResults);
                q.setFirstResult(firstResult);
            }
            return q.getResultList();
        } finally {
            em.close();
        }
    }

    public FCompteg findFCompteg(Integer id) {
        EntityManager em = getEntityManager();
        try {
            return em.find(FCompteg.class, id);
        } finally {
            em.close();
        }
    }

    public int getFComptegCount() {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            Root<FCompteg> rt = cq.from(FCompteg.class);
            cq.select(em.getCriteriaBuilder().count(rt));
            Query q = em.createQuery(cq);
            return ((Long) q.getSingleResult()).intValue();
        } finally {
            em.close();
        }
    }
    
}
